Download the installer via https://eclipse.org/downloads/packages/.

On Linux you have to unzip it before you can start it. On Mac the installer is delivered as a packaged application and can be installed and started via regular Mac installation procedures. On Windows and Mac you can run it directly via the delivered executable / package application.

Pick Eclipse IDE for Java Developers from the list and perform the installation.

You may have to confirm some license agreements.

image::java-ide-oomph30.png[]**

After the installation you can start the IDE directly. Remember the installation folder, in this folder you find the Eclipse installation to start it again.

In case you don’t want to use the installer, you can also directly download the Eclipse IDE for Java Developers package from: https://www.eclipse.org/downloads/packages/

Press on the link beside the package description, for example Linux 64-Bit to start the download. The links which are displayed depend on your operating system.

The download depends on your platform, it is either a compressed archive of multiple files or a packaged application (Mac).

After you downloaded the file with the Eclipse distribution, unpack it to a local directory or follow the installation procedure on Mac.

The Eclipse IDE prompts you for a workspace to store its configuration. Select an empty directory and click the OK button.

Eclipse starts and shows the Welcome page. Close this page by clicking the x beside Welcome.

After closing the welcome screen, the application should look similar to the following screenshot.

By default, Eclipse ships in a light configuration. If you prefer, you can switch to a dark theme via Window  Preferences  General  Appearance menu. The Theme selection allows you to switch to the Dark theme of Eclipse.

The workspace is the physical location (file path) for storing meta-data and (optional) your development artifacts. The meta-data stored for the workspace contains preferences settings, plug-in specific meta data, logs etc.

You can choose the workspace during startup of Eclipse or via the File  Switch Workspace  Others menu entry.

Your projects, source files, images and other artifacts can be stored inside or outside your workspace. For example, if you use Git as version control system, you typically would store the Git repositories outside of the workspace.

Eclipse provides views and editors to navigate and change content. View and editors can be grouped into perspectives.

A view is typically used to display structured data and allow to modify it directly.

For example, the Project Explorer view allows you to browse and modify files of Eclipse projects. If you rename a file via the Project Explorer the file name is directly changed without having to save.

Editors are typically used to modify a single data element, for example a text file. To apply these changes to the underlying data mode, you need to select save from the menu or the toolbar. A editor with unsaved data (a dirty editor) is marked with an asterisk left to the name of the modified file.

An Eclipse project contains source, configuration and binary files related to a certain task. It groups them into buildable and reusable units. An Eclipse project can have natures assigned to it which describe the purpose of this project. For example, the Java nature defines a project as Java project. Projects can have multiple natures combined to model different technical aspects.

Natures for a project are defined via the .project file in the project directory.

The Package Explorer view allows you to browse the structure of your projects and to open files in an editor via a double-click on the file.

It is also used to change the structure of your project. For example, you can rename files or move files and folders via drag and drop. A right-click on a file or folder shows you the available options.

For more info on the Package Explorer see Chapter Source Navigation and Link Package Explorer with editor.

The Outline view shows the structure of the currently selected source file.

The Problems view shows errors and warning messages. Sooner or later you will run into problems with your code or your project setup. To view the problems in your project, you can use the Problems view which is part of the standard Java perspective. If this view is closed, you can open it via Window  Show View  Problems.

The messages which are displayed in the Problems view can be configured via the drop-down menu of the view. For example, to display the problems from the currently selected project, select Configure Contents and set the Scope to On any element in the same project.

The Problems view also allows you to trigger a Quick fix via a right mouse-click on several selected messages. See chapter Quick Fix for details on the Quick fix functionality.

The Javadoc view shows the documentation of the selected element in the Java editor.

The Java editor is used to modify the Java source code. Each Java source file is opened in a separate editor.

If you click in the left column of the editor, you can configure its properties, for example, that line number should be displayed.

Select File  New  Java project from the menu. Enter com.vogella.eclipse.ide.first as the project name and press the Finish button to create the project.

A new project is created and displayed as a folder. Open the com.vogella.eclipse.ide.first folder and explore the content of this folder.

Create the com.vogella.eclipse.ide.first package by seleting the src folder, right-click on it and select New  Package.

Press the Finish button.

Right-click on your package and select New  Class to create a Java class.

Enter MyFirstClass as the class name and select the public static void main (String[] args) checkbox.

Press the Finish button.

This creates a new file and opens the Java editor. Change the class based on the following listing.

You could also directly create new packages via this dialog. If you enter a new package in this dialog, it is created automatically.

Now run your code. Either right-click on your Java class in the Package Explorer or right-click in the Java class and select Run-as  Java application.

Eclipse will run your Java program. You should see the output in the Console view.

Congratulations! You created your first Java project, a package, a Java class and you ran this program inside Eclipse.

To run the Java program outside of the Eclipse IDE, you need to export it as a JAR file. A JAR file is the standard distribution format for Java applications.

Select your project, right-click it and select the Export menu entry.

Select JAR file and select the Next button. Select your project and enter the export destination and a name for the JAR file, for example myprogram.jar.

Press The Finish button. This creates a JAR file in your selected output directory.

Open a command shell, e.g., under Microsoft Windows select Start  Run and type cmd and press the Enter key. This should open a console window.

Switch to the directory which contains the JAR file, by typing cd path. For example, if your JAR is located in c:\temp, use the following command.

To run this program, include the JAR file in your classpath. The classpath defines which Java classes are available to the Java runtime. You can add a JAR file to the classpath with the -classpath option.

Type the above command in the directory you used for the export and you see the "Hello Eclipse!" output in your command shell.

Create a new Java project called com.vogella.ide.counter.

Create the following packages:

Create the following Counter class in the *.util package.

Create the following Tester class in the *.main package. This is a simple class without the usage of any unit testing framework like JUnit. The Eclipse editor should mark the created class with an error because the required import statements are missing.

Right-click in your Java editor and select Source  Organize Imports to add the required import statements to your Java class.

This should remove the syntax error. Finish the implementation for the Tester class based on the following code.

The Counter class had in its source code a comment starting with TODO. Finish the source code and calculate the correct values.

Run the Tester class and validate that your implementation is correct. The Tester class checks for an example value but the method should work for different input values.

You can export and import Eclipse projects. This allows you to share projects with other people and to import existing projects.

To export Eclipse projects, select File  Export  General  Archive File and select the projects you want to export.

To import projects, select File  Import  Existing Projects into Workspace. You can import from an archive file, i.e., zip file or directly import the projects in case you have extracted the zip file.

Export your one of your projects into a zip file. Switch into a new workspace and import the project into your new workspace based on the zip file you exported.

The primary way of navigating through your project is the Package Explorer or alternatively the Project Explorer view. You can open nodes in the tree and open a file in an editor by double-clicking on the corresponding entry in the tree hierarchy.

The drop-down menu in the Package Explorer allows you to filter the resources which should be displayed or hidden.

The Package Explorer view allows you to display the associated file from the currently selected editor. For example, if you are working on the Foo.java file in the Java editor and switch to the Java editor of the Var.java file, then the corresponding file will be selected in the Package Explorer view.

To activate this behavior, press the Link with Editor button in the Package explorer view as depicted in the following screenshot.

You can navigate between the classes in your project via the Package Explorer view as described before. You can navigate the tree and open a file via a double-click.

In addition, you can open any class by positioning the cursor on the class in an editor and pressing F3. Alternatively, you can press Ctrl+Shift+T. This shows the following dialog in which you can enter the class name to open it.

You can also search for package names. Each part of the package name must end with a . (the dot character) so that the Open Type Dialog can identify it as a package.

The Open Type Dialog also supports CamelCase like search, e.g., it matches capital letters in the class name. For example, if you would search for the OnTouchListener class you could use OTL or OToList as search term.

You can open any file from your open projects via the Open Resource dialog. You can open this dialog via the Ctrl+Shift+R shortcut. This dialog allows to enter the file name and to open or show it in a selected view. The following screenshot demonstrate the usage to open a pom.xml file from your workspace.

Quick Outline shows you an structured overview of the file you are editing. For example, for a Java class you see its methods with the option to filter. The shortcut for opening the Quick Outline is Ctrl+O. You can also reach this option, via right-click in an editor via the Quick Outline option.

By default, Quick Outline shows only the direct members and fields of the Java class. Press Ctrl+O again to show also the inherited members and fields.

The default look of the Quick Outline option is similar to the Quick Outline view of the Java perspective.

The type hierarchy of a class shows you which classes it extends and which interfaces it implements. You can use the type hierarchy to navigate to one of these elements.

To open the type hierarchy of the selected class, right-click in the editor and select Open Type Hierarchy (Shortcut: F4) or Quick Type Hierarchy (Shortcut: Ctrl+T).

You frequently need to find files containing certain text or other meta data. Via the Search  Search…​ (Shortcut: Ctrl+H) you can open the search dialog of Eclipse. Use the File Search tab to search for text with the option to use regular expressions and also to replace matching entries.

Eclipse associates file extensions with the default tab. You can customize the available search tabs via the Customize button in the Search dialog. Via the Remember the last used page you can configure Eclipse to use your last tab as default.

The Search functionality (Ctrl+H) offers specialized searches for more complex use cases. For example, use the Java Search tab to search for Java elements, e.g., methods.

The Search view shows the search results for the selected scope. You can double-click on a search entry to navigate to the corresponding position in the editor. The currently selected search result is also indicated via an arrow in the left border of the editor.

You can use the Ctrl+J shortcut to activate Incremental Find. This allows you to search in the current active editor for a text which is displayed in the status line as depicted by the following screenshot. Repeat Ctrl+J in order to move to the next occurrence of the current search term.

The advantage of this search is that no pop-up dialog is opened which blocks other elements in the Eclipse IDE.

If you have selected an element in the editor, you can use the Ctrl+K shortcut to search for the next occurrence of the selected text and Ctrl+Shift+K for the previous element.

You can also navigate via the annotation buttons, e.g., for jumping to the next error or warning in your source code.

By pressing the buttons you can navigate to the related annotations. You can also use the keyboard shortcut Ctrl+. (Ctrl plus the dot sign) for selecting the next annotation or Ctrl+, (Ctrl plus the comma sign) for selecting the previous annotation.

The following screenshot shows source code with two warnings and one error and you can navigate between the corresponding code via the annotation buttons.

Which annotations are relevant for navigation can be configured via the drop-down menu of the toolbar. This selection is highlighted in the following screenshot.

In a lot of cases you can also use the mouse to navigate to or into an element if you press the Ctrl key. For example, press the Ctrl key and (left) click with the mouse on the name of a class to jump into the class declaration.

Similar to the left mouse click combined with the Ctrl, you can use the F3 key to go into a class.

You can also activate the breadcrumb mode for the Java editor which allows you to navigate the source code directly from the Java editor.

You can activate this mode via right-click in the editor and by selecting the Show in Breadcrumb entry.

This allows you to navigate the source code from the editor as depicted in the following screenshot.

To hide it again, right-click on a breadcrump entry and select Hide Breadcrumb.

There are a lot of shortcuts available for navigation. Please check the appendix of this tutorial for these shortcuts or open Window+Preferences  General  Keys to find and redefine shortcuts at runtime.

Closing projects saves memory in Eclipse and can reduce the build time. Eclipse ignores closed projects, e.g., all searches ignore files from closed projects. Also the Problems view does only shows errors of opened projects. This typically helps you focus your attention on the project. You can close projects via a right-click on it and by selecting the Close Project menu entry. Alternatively, if you work on a project, you can close all unrelated projects via a right-click on it and by selecting the Close Unrelated Projects menu entry.

To open a closed project double-click on it, or right-click it and select Open Project.

You can use the filter functionality for the Package Explorer view to hide the closed projects.

Content assist is a functionality in Eclipse which allows the developer to get context-sensitive code completion in an editor upon user request.

It can be invoked by pressing Ctrl+Space.

For example, type syso in the editor of a Java source file and then press Ctrl+Space. This will replace syso with System.out.println("").

If you have a reference to an object, for example, the object person of the type Person and need to see its methods, type person. and press Ctrl+Space.

Whenever the Eclipse Java tooling detects a problem in your code, it underlines the problematic text in the editor and create a problem marker. The problem marker is visible in the Problems View and in the editor via markers on the left side of the editor . Select the underlined text and press Ctrl+1 to see suggestions for correcting the problem. This functionality is called Quick Fix.

For example, type myBoolean = true; If myBoolean is not yet defined as a field, Eclipse highlights this statement as an error. Select the variable and press Ctrl+1. Eclipse suggests creating a field or local variable.

Quick Fix is extremely powerful. For example, it allows you to create new local variables and fields as well as new methods and new classes. Or it can put try/catch statements around your exceptions. It can also assign a statement to a variable and much more.

Quick Fix also gives several options for code changes on code which does not contain errors, e.g., it allows you to convert a local variable to a field.

The Eclipse IDE has full support for modern Java versions. This section demonstrates the quick fix for converting anonymous inner classes to lambda expressions.

You can use a quick fix for the conversion as demonstrated via the following screenshots.

In this exercise you practice the usage of code generation and the usage of the Content Assists functionality.

Create a project called com.vogella.ide.todo.

Create the com.vogella.ide.todo package and the following class.

Select Source  Generate Constructor using Fields…​ to generate a constructor using all fields.

Use the Source  Generate Getter and Setter to create getters and setters for all fields.

The resulting class should look like the following listing.

Use Eclipse to generate a toString() method for the Todo class based on the id and summary field.

This can be done via the Eclipse menu Source  Generate toString()…​.

Also generate a hashCode() and equals() method based on the id field. This can be done via the Source  Generate hashCode() and equals()…​ menu entry.

Create a new class called TodoProvider. Create the following static method in your TodoProvider class.

Write another TodoProviderTest class with a public static void main (String[] args) method.

In your main method call the createInitialModel method and validate that the returned number of items is 5.

If another number than 5 is returned, throw a RuntimeException. If the correct number is returned, write the String "Correct" to the Console view.

Use Content assist to create the System.out.println() based on syso for you.

While this exercise was about code generation and content assists, you might be interested in a potential solution for this exercise. The following listing contains a potential solution.

Refactoring is the process of restructuring the code without changing its behavior. For example, renaming a Java class or method is a refactoring activity.

Eclipse supports several refactoring activities, for example, renaming or moving.

For example, to use the Rename refactoring, you can right-click on your class (in the editor or Package Explorer) and select Refactor  Rename to rename your class. Eclipse will make sure that all calls in your Workspace to your class or method are renamed.

The following screenshot shows how to call the Rename refactoring for a class. The cursor is positioned on the class and the context menu is activated via a right-click on the class.

The most important refactorings are listed in the following table.

Eclipse has many more refactorings. The available options depend on the selection in the Java editor. In most cases you should get an idea of the performed action by the naming of the refactoring operation.

For the next examples change the MyFirstClass class to the following code.

A useful refactoring is to mark code and create a method from the selected code. Mark now the coding of the "for" loop, right click on the selection and select Refactoring  Extract Method. Use calculateSum as the name of the new method.

After this refactoring the class should look like the following code.

You can also extract strings and create constants based on the strings. Mark for this example the "Hello Eclipse!" string in your source code, right-click on it and select Refactor  Extract Constant. Name your new constant HELLO.

The string is now defined as a constant.

You can store JAR files directly in your project, and add them to the classpath which the Java compiler of Eclipse is using. To manage the classpath for your Eclipse, right-click on your project and select Properties. Under Java Build Path  Libraries you can review and change your current classpath as depicted in the following screenshot.

JAR files can be stored outside your project or inside. To import a JAR into an existing folder, select File  Import  General  File System. Select the Java library you want to import and select the folder, e.g.,lib, as target. To add JAR file located in the project to its classpath, right-click on the JAR file and select Build Path  Add to Build Path.

You can define in Eclipse that a project is dependent on another project. If you do this, you can use its classes in the project defining the dependency. To do this select your project, right-click on it and select Properties. Select Java Build Path and the Projects tab.

This only works within Eclipse, it allows you to develop several projects which will later be exported as JAR files together. Outside of Eclipse you need to create Java libraries for the projects and add them to the classpath.

You can open any class by positioning the cursor on the class in an editor and pressing F3. Alternatively, you can press Ctrl+Shift+T. This shows a dialog in which you can enter the class name to open it.

If the source code is not available, the editor shows the bytecode of that class.

This happens, for example, if you open a class from a the standard Java library without attaching the source code to it.

To see the source code of such a class, you can attach a source archive or source folder to a Java library. Afterwards, the editor shows the source instead of the bytecode.

Attaching the source code to a library also allows you to debug this source code.

The Source Attachment dialog can be reached in the Java Build Path page of a project. To open this page, right-click on a project and select Properties  Java Build Path. On the Libraries tab, expand the library’s node, select the Source Attachment attribute and click the Edit button.

In the Location path field, enter the path of an archive or a folder containing the source.

The following screenshot shows this setting for the standard Java library. If you have the Java Development Kit (JDK) installed, you should find the source in the JDK installation folder. The file is typically called src.zip.

It is also possible to add Javadoc to a library which you use. For this you need to have the Javadoc somewhere in your filesystem. To configure the location of the Javadoc for the JAR File, open the Java Build Path via a right-click on a project. Select Properties  Java Build Path. On the Libraries tab expand the library’s node, select the Javadoc location attribute and press the Edit button.

Enter the location to the file which contains the Javadoc.

The Eclipse IDE allows you to install and update software components. The Eclipse update functionality only downloads new or updated components.

Installable software components are located in update sites. Update sites can be located on a web server or on the file system.

To update your Eclipse installation, select Help  Check for Updates. The system searches for updates in the configured update sites for the installed software components. If it finds updated components, it will ask you to approve the update.

To install a new functionality, select Help  Install New Software…​.

From the Work with list, select or enter a URL for the update site you want to use. Entering a new URL adds this URL automatically to the list of available update sites.

To explicitly add a new update site, press the Add…​ button and enter the new URL as well as a name for the new update site.

The following update sites contain the official Eclipse components.

If you select a valid update site, Eclipse allows you to select components and install them.

If you can’t find a certain component, uncheck the _Group items by category _ checkbox because not all available plug-ins are categorized. And not categorized items are only displayed if the grouping is disabled.

To see which components are installed, use Help  About Eclipse SDK  Installation Details.

If you select Help  About Eclipse SDK and then the Installation Details button, you can uninstall components from your Eclipse IDE.

After an update or an installation of a new software component, you should restart Eclipse to make sure that the changes are applied.

Eclipse contains a client which allows installing software components from the Eclipse marketplace. The advantage of this client is that you can search for components, discover popular extensions and see descriptions and ratings.

Compared to the update manager, you do not have to know the URL for the software site which contains the installable software components.

Most Eclipse distributions contain the Marketplace client by default. You may need to install the Marketplace client software component into Eclipse before you can use it. The following screenshot shows how to install it from one of the official Eclipse update sites, via the Help  Install New Software…​ dialog.

To open the Eclipse Marketplace, select Help  Eclipse Marketplace…​.

You can use the Find box to search for components. Pressing the Install button starts the installation process.

The marketplace client allows to install your favorite plug-ins directy. For this, go to the Eclipse Marketplace website and login with your Eclipse.org account.

Now search on the website for your favorite and press the * sign.

Afterwards, select the Favorites tab in the Eclipse Marketplace client and login to be able to install your favorites.

Eclipse plug-ins are distributed as jar files. If you want to use an Eclipse plug-in directly or do not know the update site for it, you can place it in the dropins folder of your Eclipse installation directory. Eclipse monitors this directory and during a (re-)start of your IDE, the Eclipse update manager installs and removes plug-in based on the files contained in this directory.

You should not modify the content of the Eclipse plugins directory directly. If you want to install plug-ins, put them into the dropins folder. If you want to remove it, delete the JAR from this folder.

Plug-ins are typically distributed as jar files. To add a plug-in to your Eclipse installation, put the plug-in .jar file into the Eclipse dropins folder and restart Eclipse. Eclipse should detect the new plug-in and install it for you.

If you remove plug-ins from the dropins folder and restart Eclipse, these plug-ins are automatically removed from your Eclipse installation.

Eclipse allows you to export a file which describes the installed Eclipse components. During the export the user can select which components should be included into this description file.

Other users can import this description file into their Eclipse installation and install the components based on this file.

This way, Eclipse installation can be kept in sync with each other.

To export a description file, select File  Export  Install  Installed Software Items to File. Select the components which should be included in your description file.

To install the described components in another Eclipse installation, open the exported file with File  Import  Install  Install Software Items from File and follow the wizard. The wizard allows you to specify the components which should be installed.

The Eclipse update manager has a component called director which allows you to install new features via the command line.

For example, the following command will install the components EGit, Mylyn and EMF into an Eclipse instance. You need to start this command in the command line and it assumes that you are in a directory which contains your Eclipse installation in a folder called eclipse.

The feature names which you need for this operation can be seen on the second page of the standard installation dialog of the Eclipse update manager.

The behavior of the Eclipse IDE can be controlled via key value pairs stores as preference settings. Each Eclipse software component can define such perferences and use the values to configure itself. This allows you for example to configure how long the Eclipse waits before the code completion or if the import statements in your source code should be automatically adjusted if you save your source code.

Which preferences are key values stored on the file system, the Eclipse IDE allows the user to configure most of these values via the preference dialog.

Select Window  Preferences to open the preference dialog. You can use the filter box to search for specific settings.

Correctly configuring Eclipse to your needs can largely improve your productivity. Most of these preference settings are specific to your workspace but some are also valid for all workspaces.

You can specify default values for preferences via a file which is typically called plugin_customization.ini.

In this file you enter default values for preference settings. For example, the following will set up a default type filter for the java.awt and javax.swing package.

You link to this file via your eclipse.ini file in your Eclipse installation directory.

The following example eclipse.ini links to the file and it assumes that you created the plugin_customization.ini file in the Eclipse installation directory.

To identify a key for a certain preference setting you can export existing preference settings via the following approach.

You can synchronize the currently selected Java editor with the selection in the Project Explorer or the Package Explorer view. This gives you a clearer visibility which object you are currently editing.

Enable this by selecting the corresponding button in the view.

Eclipse can make typing more efficient by placing semicolons at the correct position in your source code.

In the Preference setting select Java  Editor  Typing. In the Automatically insert at correct position selection enable the Semicolons checkbox.

Afterwards, you can type a semicolon in the middle of your code and Eclipse positions it at the end of the current statement.

Eclipse allows you to escape text automatically if it is pasted into a String literal. For example, you can copy HTML code and paste it into a String in your Java source. Eclipse would escape the text automatically for you.

Activate this setting via Window  Preferences  Java  Editor  Typing  In string literals  Escape text when pasting into string literal

Now you can paste text that should be escaped. The following code snippet shows an example for the resulting code if you paste HTML code containing a link into a string literal.

You can configure Eclipse to highlight the matching brackets of a code block in the source code editor.

Before the change you would not see the enclosing brackets. Afterwards, they will be slightly highlighted. This helps to see in which block you are.

Eclipse allows you to start an application via the Run button in the menu or via the Ctrl+F11 shortcut. By default, Eclipse determines if the currently selected file is executable and try to start that. This is sometimes confusing. You can configure the Eclipse IDE to always start the last started program.

To configure this, select Window  Preferences  Run/Debug  Launching. In the Eclipse preferences dialog select the Launch the previously launched application option in the Run/Debug  Launching setting.

To add import statements to your code, you can use the Organize Imports action (shortcut: Ctrl+Shift+O). If there are several alternatives, Eclipse suggests all available packages and the user has to select the right one.

The following shows the available packages for the List class in the Organize Imports dialog.

If you never use certain packages, for example AWT or Swing, you can exclude these packages from Eclipse via the Window  Preferences  Java  Appearance  Type Filters setting.

Press the Add packages button to add a specific package or the Add…​ button to use wildcards. The setting in the following screenshot excludes the java.awt and java.swing packages from the possible imports and other Java search functionality.

Eclipse can perform actions during the save operation (shortcut: Ctrl+S)., e.g., format your source code, organize your imports can cleanup your code. You can find the corresponding settings under Window  Preferences  Java  Editor  Save Actions.

Select that the source code should be formated and that the imports should be organized at every save action.

You can also define the additional actions which are performed during save. Via the Configure…​ button you can select which one you want to activate.

Eclipse can override existing method calls, in case you trigger a code completion in an existing statement. Eclipse can also try to guess the correct actual parameters for a method call.

With the first setting you can override methods in the middle of a statement via the Ctrl+Space code assists shortcut.

Without this setting you would get the following result, which results in a syntax error.

With this setting you get the following result.

The Eclipse IDE is configured to give you automatic code completion suggestion only after the . sign. YOu can configure Eclipse to get code completion on every character. Open again the Window  Preferences  Java  Editor  Content Assists preference setting and enter .abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVXYZ in the Auto activation trigger for Java.

You can configure these checks in the Eclipse preferences settings via the Java  Compiler  Errors/Warnings entry.

You can enable annotation-based null checks in Eclipse via the setting highlighted in the following screenshot.

After enabling this setting, you can use the @NonNull annotation on method parameters or variable definitions to indicate that these are not allowed to be NULL. You can also use the @Nullable annotation to define that a variable can be NULL.

Eclipse has the option to perform cleanup actions on existing code. This includes the removal of trailing whitespace, the additional of missing annotations but also advanced cleanups like the conversion of code to Java 8 lambda expressions.

To trigger this cleanup, select the Java source file, package or project and select Source  Clean-up…​ from the context menu.

Select Use custom profile and press Configure…​ to configure the actions which should be performed on your code.

After finishing the configuration, press OK and the Next button in the cleanup wizard to get a preview of the changes.

Open Window  Preferences  Java  Editor  Save Actions.

Select that the source code should be formated and that the imports should be organized at every save action.

You can also define the additional actions which are performed during save. Via the Configure…​ button you can select which one you want to activate.

You can define how the Java compiler should react to certain common programming problems. For example, you can define that an assignment of a variable which has no effect, e.g., x=x, causes an error in Eclipse.

Eclipse has the option to perform batch cleanup on existing code. This includes simple thinks like the removal of trailing whitespace, the additional of missing annotations but also advanced cleanups like the conversion of code to Java lambda expressions. The cleanups contain also lots of options to improve the performance of your code.

To trigger this cleanup, select the Java source file, package or project, right-click on it and select Source  Clean-up…​ from the context menu.

Select Use custom profile and press Configure…​ to configure the actions which should be performed on your code.

After finishing the configuration, press OK and the Next button in the cleanup wizard to get a preview of the changes.

The Editors which are available to open a file can be configured via Window  Preferences  General  Editors  File Associations.

The Default button in this preference dialog allows you to set the default editor for a certain file extension. This edit is used by default, if you open a new file with this extension.

The other configured editors can be selected if you right-click on a file and by selecting Open With. In the sub-menu you see the available editors. The available editors depend on your Eclipse installation.

Eclipse remembers the last editor used to open a file. It uses this editor again the next time you open the file.

You can export your preference settings from one workspace via File  Export  General  Preferences.

Eclipse does allow you to export some preference settings separately, but for most of them you have to select the Export all flag.

Similarly, you can import them again into another workspace via File  Import  General  Preferences.

You can also configure certain preference settings on a per project basis. To do this, select your project, right-click on it and select Properties. For example, on the Java Editor  Save Actions you can select the Enable project specific settings checkbox to configure the save action for the current project only.

This creates a .settings folder. You can add this folder to your version control system to ensure that every developer uses the same setting.

You can create templates for Java code snippets which you can insert via via autocomplete (Ctrl+Space) in the Java code editor. For example, assume that you are frequently creating public void name(){} methods. You could define a template which creates the method body for you

To create a new template, select the menu Window  Preferences  Java  Editor  Templates.

Press the New button. Create the following template.

${cursor} indicates that the cursor should be placed at this position after applying the template.

In this example the name npm is your keyword for code completion.

Now, if you type npm in the Java editor and press Ctrl+Space, you can insert your template.

Eclipse allows you also to specify the settings for formatting the source code. These rules are used by Eclipse if you automatically format your source code.

You find the settings under Window  Preferences  Java  Code Style  Formatter.

Press the New button to create a new set of formatting rules or press the Edit button to adjust an existing profile.

Eclipse can generate source code automatically. In several cases comments are added to the source code.

Select Window  Preferences  Java  Code Style  Code Templates to change the code-generation templates.

In the code tree you have the templates. Select, for example, menu:Code [Method Body] and press the Edit button to edit this template and to remove the "todo" comment.

Create a template which creates the following block.

Place the cursor after the first bracket after the try statement.

Test your template in the Java editor and ensure that it works as expected.

Your Eclipse installation contains a file called eclipse.ini which allows you to configure the memory parameters for the Java virtual machine which runs the Eclipse IDE. For example, the -Xmx parameter can be used to define how large the Java heap size can get. -Xms defines the initial heap size of the Java virtual machine.

The following listing shows an example eclipse.ini file. The parameters after -vmargs configure the Java virtual machine. On a modern machine (with at least 8 Gigabyte available memory) assigning 2024 MB or more to the Java virtual machine is a good practice to run Eclipse faster.

You can in additional also turn of class verification in the JVM. This avoids that the JVM checks if the class data which are loaded is not corrupt or invalid. This check is only really important if byte code in manipulated and adds 10-20% additional startup time. To disable this check add the -Xverify:none option option on your JVM.

Eclipse allows you to configure it via startup parameters. This requires that you start Eclipse from the command line or that you configure your launcher links to include these parameters.

The following table shows important parameters.

For example, if you want to start Eclipse under Microsoft Windows using the c:\temp directory as workspace, you can start Eclipse via the following command from the command line.

Depending on your platform, you may have to put the path name into double quotes.

Eclipse keeps a local history of files which have changed. Every time an editable file is saved, the Eclipse runtime updates the local history of that file and logs the changes that have been made. This local history can then be accessed and used to revert the file changes or to compare against a previous version.

To compare the current version of a file with a local version stored by Eclipse, right-click on the file and select Compare With  Local History…​ from the context menu. Eclipse opens the History view.

If you double-click on an older version of the file, the Compare view shows the differences as depicted in the following screenshot.

You can replace files based on the local history. Right-click on the file and select Replace With  Local history…​ to start this action.

You can place markers in the code which you can later access via the Task view.

You can use // TODO, // FIXME or // XXX tags in your code to add task reminders.

This indicates a task for Eclipse. You find those in the Task view of Eclipse. Via double-clicking on the task, you can navigate to the corresponding code.

You can open this view via Window  Show View  Tasks.

For example, add a TODO to your MyFirstClass class to see it in the Tasks view.

Close the editor for the MyFirstClass class. If you now double-click on the tasks, the Java editor opens again and the TODO comment is selected.

TIP:The Task view shows only the tasks from the currently open projects.

You can also define your own tags in the Eclipse preferences via Window  Preferences  Java  Compiler  Task Tags.

A more advanced tasks management system is available with the Mylyn plug-in.

The Eclipse help system is available from within your Eclipse installation as well as online.

With your running Eclipse IDE you can access the online help via Help  Help Contents. This will start a new window which shows you the help topics for your currently installed components.

You find the online help for the current release of the Eclipse IDE under the following URL: Eclipse online help. The online help is version-dependent and contains the help for all Eclipse projects of the simultaneous release.

The Eclipse webpage also contains a list of relevant resources about Eclipse and Eclipse programming. You find these resources under the following link: Eclipse resources.

You also find lots of tutorials about the usage of the Eclipse IDE from the vogella GmbH on the following webpage: vogella Eclipse IDE tutorials.

Information about Eclipse plug-in and RCP development from the vogella GmbH can be found on the following webpage: Eclipse Plug-in and RCP tutorials.

If you encounter a problem with the Eclipse IDE or think about a potential improvement for it, you should report this to the Eclipse project. The Eclipse bug and feature tracker is using the open source Bugzilla project from Mozilla. In this system, you enter Eclipse error reports. You can also request new features or improvements of existing features.

This bug tracker can be found under Eclipse Bugzilla. Here you can search for existing bugs and review them.

To participate actively in the Eclipse bug tracker, you need to create a new account. This can be done by clicking the Create a New Account link.

Once you have a user account, you can login to the Eclipse bug tracker. This allows you to comment on existing bugs and report new ones. The user data for the all Eclipse sites are the same, i.e, the forum, marketplace, bug tracker, etc. Only for the Gerrit access, different user data is used.

As example you can report bugs for the Eclipse platform via the following link: Bug report for the Eclipse platform.

The Eclipse Bugzilla system allows you and the Eclipse committer to enter the bug priority. But overall, it is up to each project do decide how they handle bugs so some variation from project to project will occur. The following rules can be used as guideline.

Open to Eclipse Bugzilla and select the Search button. Select the Advanced Search tab and search for Eclipse  Platform  UI for all bugs in status NEW, ASSIGNED, UNCONFIRMED and REOPENED.

In most cases Eclipse project have tons of unsolved bugs. If you are looking for existing software bugs, it is recommended to look at the latest bugs, e.g., the bugs which have been recently updated.

Eclipse IDE book from Lars Vogel

Eclipse Homepage

Eclipse Forum for asking questions and providing feedback

Eclipse Bug Tracker for reporting errors or feature requests

If you need more assistance we offer Online Training and Onsite training as well as consulting

See License for license information.